#include <bits/stdc++.h>
using namespace std;


//---------------------------------
//不能被复制的类，简单就是禁用拷贝构造和赋值重载
class NonCopy{
    public:
    NonCopy(){};
    
    
    // //直接删掉
    // NonCopy(const NonCopy& NC)=delete;
    // NonCopy operator=(const NonCopy& NC)=delete;
    //-------
    
    //下面是C++98做法，就是设置成私有
    private:
    NonCopy(const NonCopy& NC){};
    void operator=(const NonCopy& NC){};
};

void Test_NonCopy()
{
    NonCopy a;

    //解放注释就会发现提供报错了
    // NonCopy b(a);
    // NonCopy c;
    // c = a;
}


//------------------------------------------
//只能能在堆上创建的类


class OnlyCreatInHeap{
    //方法一：私有化其构造函数和析构函数     
    OnlyCreatInHeap()
    {
        cout<<"constructor is called\n";
    }
    ~OnlyCreatInHeap()
    {
        cout<<"destructor is called\n";
    }
    //就但凭借上述还不足够，还有个可以做到，就是拷贝构造，其可以借用现有对象去创建
    OnlyCreatInHeap(const OnlyCreatInHeap & it)
    {
        //拷贝构在此处
        cout<<"Copy constructor is called\n";
    }
    public:         
    //这个时候捏，对象大多数时候还没有创建，所以设置成static，防止乱使用this指针，也让外部调用更加便利
    static OnlyCreatInHeap* Creat()
    {
        return new OnlyCreatInHeap;
    } 
    static OnlyCreatInHeap* copy_construct(const OnlyCreatInHeap & it)
    {
        return new OnlyCreatInHeap(it);
    }
    void Des()
    {
        delete this;
    }  

};

void HeapOnly()
{
    // OnlyCreatInHeap a;//无法调用构造函数或者是析构是私有无法创建
    OnlyCreatInHeap*p = OnlyCreatInHeap::Creat();
    p->Des();
    // OnlyCreatInHeap a(*p);//此处会报错了
}


//----------------------------------------------
//创建只能在栈上创建的对象
//方法一：也可以私有化对应的构造函数，设计个静态函数的构造函数就可以
//方法二：删除使得new失效，但是也会使得定位new失效，
//下面展示的是方法二


class OnlyCreatInStack
{
    public:
    OnlyCreatInStack()
    {
        cout<<"constructor is called\n";
    }
    public:
    //这里返回临时对象就好了，像g++编译器，优化的十分厉害，检测到连续的构造拷贝构造，直接就修改作用域和生命周期以达到目的
    static OnlyCreatInStack CreatObj()
    {
        return OnlyCreatInStack();
    }
    //如同只在堆上创建一样，拷贝构造也应该想办法不要再new里面实现，但是又不能设为私有之类的操作，因为拷贝构造栈上也要用
    //有如下解决
    //实现专属的new运算符，这样这个类就new就会搞这个，然后给他delete
    void* operator new(size_t size) =delete;
    void operator delete(void* p)=delete;
};

// void*  OnlyCreatInStack:: operator new(size_t size)
// {
//     OnlyCreatInStack* p = (OnlyCreatInStack*)malloc(sizeof(OnlyCreatInStack));
//     ::new(p) OnlyCreatInStack;//调用用全局的定位new，也是不行的
//     return p;
// }
int Test_CreatOnlyInStack()
{
    OnlyCreatInStack a(OnlyCreatInStack::CreatObj());
    //OnlyCreatInStack* p = new OnlyCreatInStack;//这样new就行不通了
    // OnlyCreatInStack* p = new OnlyCreatInStack(a);//这样new就行不通了

    return 0;
}


//------------------------------------------------
//设计一个不能继承的类，C++98里面用的是构造函数私有化，C++11可以加关键字final

class NonInherited  final
{

};

//这里直接就无通过语法检查
// class Son :public NonInherited
// {

// };





//------------------------------------------------------
//设计一个类。使其只能有一个对象
//首先根据特点，我们拒绝多次实例化和拷贝
//显然是不允许存在拷贝构造，构造函数的,因此私有化
//一般来说呢，私有化了拷贝构造，也应该私有化赋值重载


//ok,上面的基本要求做完，接下来解决单例的构建问题
//饿汉模式：一开始就创建好，一般来说在main之前，那么我们思考在main函数之前，就创建的一般就是静态区
//////：具备全局属性或者静态属性,因此可以在在类的局部里面操作这个问题
//优点：设计简单
//缺点：使得进程启动慢，甚至是卡住启动,如果单例有先后顺序，那么就无法控制
class OnlyOne{

    typedef OnlyOne Self;
    private:
    OnlyOne(const string& s = "",const int& a = 0)
    :m()
    {
        cout<<"OnlyOne begin"<<endl;
    }
    OnlyOne(const Self& him)
    {

    };
    Self operator=(const Self& him)
    {
        return *this;
    };
    ~OnlyOne()
    {
        cout<<"OnlyOne end"<<endl;
    }
    static OnlyOne _inst;
    map<string,int> m;
    public:
    static Self* GetPtr()
    {
        return &_inst;
    }
    void Add(const string& s,int k)
    {
        m[s] = k;
    }
    void Print()
    {
        for(auto it:m)
        {
            cout<<it.first<<' '<<it.second<<endl;
        }
    }
    
};

OnlyOne OnlyOne::_inst ;

int OnlyOne1()
{
    OnlyOne* p = OnlyOne::GetPtr();
    p->Add("1",2);
    p->Add("2",3);
    p->Print();
    return 0;
}



//懒汉模式：使用的时候再实例化
//to do：线程安全问题没有解决   ################################
//new的懒汉都想一般不需要释放,因为程序结束就自动回收资源了
//僵尸进程，提前释放都很少遇见
//如果遇见要求写数据到磁盘，就需要调用析构函数
class OnlyOne2{
    private:
    OnlyOne2()
    {
        cout<<"OnlyOne2 begin"<<endl;
    }
    OnlyOne2(const OnlyOne2& s) = delete;
    OnlyOne2 operator=(const OnlyOne2& s) = delete;
    ~OnlyOne2()
    {
        
        cout<<"OnlyOne2 end"<<endl;
    }
    map<string,int> m;
    static OnlyOne2 *_inst;
    class gc{
        public:
        ~gc()
        {
            DelInst();
        }
    };
    static gc _gc;
    public:
    
    
    static OnlyOne2* GetPtr()
    {
        if(_inst){
            return _inst;
        }
        return _inst = new OnlyOne2;
    }
    void Add(const string& s,int k)
    {
        m[s] = k;
    }
    void Print()
    {
        for(auto it:m)
        {
            cout<<it.first<<' '<<it.second<<endl;
        }
    }
    static void DelInst()
    {
        if(_inst)
        {
            delete _inst;
            _inst = nullptr;
        }
    }
};

OnlyOne2* OnlyOne2:: _inst =nullptr;
OnlyOne2::gc OnlyOne2::_gc;
int main()
{ 
    OnlyOne2* p = OnlyOne2::GetPtr();
    p->Add("1",2);
    p->Add("2",3);
    p->Print();
    return 0;
}